﻿using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using HslCommunication.BasicFramework;
using HslCommunication.LogNet;
using HslCommunication.Reflection;

namespace HslCommunication.Core.Net
{
	/// <summary>
	/// 所有虚拟的数据服务器的基类，提供了基本的数据读写，存储加载的功能方法，具体的字节读写需要继承重写。<br />
	/// The base class of all virtual data servers provides basic methods for reading and writing data and storing and loading. 
	/// Specific byte reads and writes need to be inherited and override.
	/// </summary>
	// Token: 0x02000138 RID: 312
	public class NetworkDataServerBase : NetworkAuthenticationServerBase, IDisposable, IReadWriteNet
	{
		/// <summary>
		/// 实例化一个默认的数据服务器的对象<br />
		/// Instantiate an object of the default data server
		/// </summary>
		// Token: 0x06001A3B RID: 6715 RVA: 0x0008418C File Offset: 0x0008238C
		public NetworkDataServerBase()
		{
			this.ActiveTimeSpan = TimeSpan.FromHours(24.0);
			this.lock_trusted_clients = new SimpleHybirdLock();
			this.ConnectionId = SoftBasic.GetUniqueStringByGuidAndRandom();
			this.lockOnlineClient = new object();
			this.listsOnlineClient = new List<AppSession>();
			this.timerHeart = new Timer(new TimerCallback(this.ThreadTimerHeartCheck), null, 2000, 10000);
		}

		/// <summary>
		/// 将本系统的数据池数据存储到指定的文件<br />
		/// Store the data pool data of this system to the specified file
		/// </summary>
		/// <param name="path">指定文件的路径</param>
		/// <exception cref="T:System.ArgumentException"></exception>
		/// <exception cref="T:System.ArgumentNullException"></exception>
		/// <exception cref="T:System.IO.PathTooLongException"></exception>
		/// <exception cref="T:System.IO.DirectoryNotFoundException"></exception>
		/// <exception cref="T:System.IO.IOException"></exception>
		/// <exception cref="T:System.UnauthorizedAccessException"></exception>
		/// <exception cref="T:System.NotSupportedException"></exception>
		/// <exception cref="T:System.Security.SecurityException"></exception>
		// Token: 0x06001A3C RID: 6716 RVA: 0x00084224 File Offset: 0x00082424
		public void SaveDataPool(string path)
		{
			byte[] bytes = this.SaveToBytes();
			File.WriteAllBytes(path, bytes);
		}

		/// <summary>
		/// 从文件加载数据池信息<br />
		/// Load datapool information from a file
		/// </summary>
		/// <param name="path">文件路径</param>
		/// <exception cref="T:System.ArgumentException"></exception>
		/// <exception cref="T:System.ArgumentNullException"></exception>
		/// <exception cref="T:System.IO.PathTooLongException"></exception>
		/// <exception cref="T:System.IO.DirectoryNotFoundException"></exception>
		/// <exception cref="T:System.IO.IOException"></exception>
		/// <exception cref="T:System.UnauthorizedAccessException"></exception>
		/// <exception cref="T:System.NotSupportedException"></exception>
		/// <exception cref="T:System.Security.SecurityException"></exception>
		/// <exception cref="T:System.IO.FileNotFoundException"></exception>
		// Token: 0x06001A3D RID: 6717 RVA: 0x00084244 File Offset: 0x00082444
		public void LoadDataPool(string path)
		{
			bool flag = File.Exists(path);
			if (flag)
			{
				byte[] content = File.ReadAllBytes(path);
				this.LoadFromBytes(content);
			}
		}

		/// <summary>
		/// 从字节数据加载数据信息，需要进行重写方法<br />
		/// Loading data information from byte data requires rewriting method
		/// </summary>
		/// <param name="content">字节数据</param>
		// Token: 0x06001A3E RID: 6718 RVA: 0x00009AA1 File Offset: 0x00007CA1
		protected virtual void LoadFromBytes(byte[] content)
		{
		}

		/// <summary>
		/// 将数据信息存储到字节数组去，需要进行重写方法<br />
		/// To store data information into a byte array, a rewrite method is required
		/// </summary>
		/// <returns>所有的内容</returns>
		// Token: 0x06001A3F RID: 6719 RVA: 0x0008426D File Offset: 0x0008246D
		protected virtual byte[] SaveToBytes()
		{
			return new byte[0];
		}

		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDoubleBase.ByteTransform" />
		// Token: 0x17000564 RID: 1380
		// (get) Token: 0x06001A40 RID: 6720 RVA: 0x00084275 File Offset: 0x00082475
		// (set) Token: 0x06001A41 RID: 6721 RVA: 0x0008427D File Offset: 0x0008247D
		public IByteTransform ByteTransform { get; set; }

		/// <inheritdoc cref="P:HslCommunication.Core.IReadWriteNet.ConnectionId" />
		// Token: 0x17000565 RID: 1381
		// (get) Token: 0x06001A42 RID: 6722 RVA: 0x00084286 File Offset: 0x00082486
		// (set) Token: 0x06001A43 RID: 6723 RVA: 0x0008428E File Offset: 0x0008248E
		public string ConnectionId { get; set; }

		/// <summary>
		/// 接收到数据的时候就触发的事件<br />
		/// An event that is triggered when data is received
		/// </summary>
		// Token: 0x1400003B RID: 59
		// (add) Token: 0x06001A44 RID: 6724 RVA: 0x00084298 File Offset: 0x00082498
		// (remove) Token: 0x06001A45 RID: 6725 RVA: 0x000842D0 File Offset: 0x000824D0
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event NetworkDataServerBase.DataReceivedDelegate OnDataReceived;

		/// <summary>
		/// 触发一个数据接收的事件信息<br />
		/// Event information that triggers a data reception
		/// </summary>
		/// <param name="receive">接收数据信息</param>
		// Token: 0x06001A46 RID: 6726 RVA: 0x00084305 File Offset: 0x00082505
		protected void RaiseDataReceived(byte[] receive)
		{
			NetworkDataServerBase.DataReceivedDelegate onDataReceived = this.OnDataReceived;
			if (onDataReceived != null)
			{
				onDataReceived(this, receive);
			}
		}

		/// <summary>
		/// 数据发送的时候就触发的事件<br />
		/// Events that are triggered when data is sent
		/// </summary>
		// Token: 0x1400003C RID: 60
		// (add) Token: 0x06001A47 RID: 6727 RVA: 0x0008431C File Offset: 0x0008251C
		// (remove) Token: 0x06001A48 RID: 6728 RVA: 0x00084354 File Offset: 0x00082554
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public event NetworkDataServerBase.DataSendDelegate OnDataSend;

		/// <summary>
		/// 获取或设置两次数据交互时的最小时间间隔，默认为24小时。<br />
		/// Get or set the minimum time interval between two data interactions, the default is 24 hours.
		/// </summary>
		// Token: 0x17000566 RID: 1382
		// (get) Token: 0x06001A49 RID: 6729 RVA: 0x00084389 File Offset: 0x00082589
		// (set) Token: 0x06001A4A RID: 6730 RVA: 0x00084391 File Offset: 0x00082591
		public TimeSpan ActiveTimeSpan { get; set; }

		/// <summary>
		/// 触发一个数据发送的事件信息<br />
		/// Event information that triggers a data transmission
		/// </summary>
		/// <param name="send">数据内容</param>
		// Token: 0x06001A4B RID: 6731 RVA: 0x0008439A File Offset: 0x0008259A
		protected void RaiseDataSend(byte[] send)
		{
			NetworkDataServerBase.DataSendDelegate onDataSend = this.OnDataSend;
			if (onDataSend != null)
			{
				onDataSend(this, send);
			}
		}

		/// <inheritdoc cref="P:HslCommunication.Core.Net.NetworkDeviceBase.WordLength" />
		// Token: 0x17000567 RID: 1383
		// (get) Token: 0x06001A4C RID: 6732 RVA: 0x000843B0 File Offset: 0x000825B0
		// (set) Token: 0x06001A4D RID: 6733 RVA: 0x000843B8 File Offset: 0x000825B8
		protected ushort WordLength { get; set; } = 1;

		/// <summary>
		/// 当客户端登录后，在Ip信息的过滤后，然后触发本方法，进行后续的数据接收，处理，并返回相关的数据信息<br />
		/// When the client logs in, after filtering the IP information, this method is then triggered to perform subsequent data reception, 
		/// processing, and return related data information
		/// </summary>
		/// <param name="socket">网络套接字</param>
		/// <param name="endPoint">终端节点</param>
		// Token: 0x06001A4E RID: 6734 RVA: 0x00009AA1 File Offset: 0x00007CA1
		protected virtual void ThreadPoolLoginAfterClientCheck(Socket socket, IPEndPoint endPoint)
		{
		}

		/// <summary>
		/// 当接收到了新的请求的时候执行的操作，此处进行账户的安全验证<br />
		/// The operation performed when a new request is received, and the account security verification is performed here
		/// </summary>
		/// <param name="socket">异步对象</param>
		/// <param name="endPoint">终结点</param>
		// Token: 0x06001A4F RID: 6735 RVA: 0x000843C4 File Offset: 0x000825C4
		protected override void ThreadPoolLogin(Socket socket, IPEndPoint endPoint)
		{
			string ipAddress = endPoint.Address.ToString();
			bool isTrustedClientsOnly = this.IsTrustedClientsOnly;
			if (isTrustedClientsOnly)
			{
				bool flag = !this.CheckIpAddressTrusted(ipAddress);
				if (flag)
				{
					ILogNet logNet = base.LogNet;
					if (logNet != null)
					{
						logNet.WriteDebug(this.ToString(), string.Format(StringResources.Language.ClientDisableLogin, endPoint));
					}
					socket.Close();
					return;
				}
			}
			bool flag2 = !base.IsUseAccountCertificate;
			if (flag2)
			{
				ILogNet logNet2 = base.LogNet;
				if (logNet2 != null)
				{
					logNet2.WriteDebug(this.ToString(), string.Format(StringResources.Language.ClientOnlineInfo, endPoint));
				}
			}
			this.ThreadPoolLoginAfterClientCheck(socket, endPoint);
		}

		/// <summary>
		/// 设置并启动受信任的客户端登录并读写，如果为null，将关闭对客户端的ip验证<br />
		/// Set and start the trusted client login and read and write, if it is null, the client's IP verification will be turned off
		/// </summary>
		/// <param name="clients">受信任的客户端列表</param>
		// Token: 0x06001A50 RID: 6736 RVA: 0x00084468 File Offset: 0x00082668
		public void SetTrustedIpAddress(List<string> clients)
		{
			this.lock_trusted_clients.Enter();
			bool flag = clients != null;
			if (flag)
			{
				this.TrustedClients = Enumerable.ToList<string>(Enumerable.Select<string, string>(clients, delegate(string m)
				{
					IPAddress ipaddress = IPAddress.Parse(m);
					return ipaddress.ToString();
				}));
				this.IsTrustedClientsOnly = true;
			}
			else
			{
				this.TrustedClients = new List<string>();
				this.IsTrustedClientsOnly = false;
			}
			this.lock_trusted_clients.Leave();
		}

		/// <summary>
		/// 检查该Ip地址是否是受信任的<br />
		/// Check if the IP address is trusted
		/// </summary>
		/// <param name="ipAddress">Ip地址信息</param>
		/// <returns>是受信任的返回<c>True</c>，否则返回<c>False</c></returns>
		// Token: 0x06001A51 RID: 6737 RVA: 0x000844E8 File Offset: 0x000826E8
		private bool CheckIpAddressTrusted(string ipAddress)
		{
			bool isTrustedClientsOnly = this.IsTrustedClientsOnly;
			bool result;
			if (isTrustedClientsOnly)
			{
				bool flag = false;
				this.lock_trusted_clients.Enter();
				for (int i = 0; i < this.TrustedClients.Count; i++)
				{
					bool flag2 = this.TrustedClients[i] == ipAddress;
					if (flag2)
					{
						flag = true;
						break;
					}
				}
				this.lock_trusted_clients.Leave();
				result = flag;
			}
			else
			{
				result = false;
			}
			return result;
		}

		/// <summary>
		/// 获取受信任的客户端列表<br />
		/// Get a list of trusted clients
		/// </summary>
		/// <returns>字符串数据信息</returns>
		// Token: 0x06001A52 RID: 6738 RVA: 0x00084564 File Offset: 0x00082764
		public string[] GetTrustedClients()
		{
			string[] result = new string[0];
			this.lock_trusted_clients.Enter();
			bool flag = this.TrustedClients != null;
			if (flag)
			{
				result = this.TrustedClients.ToArray();
			}
			this.lock_trusted_clients.Leave();
			return result;
		}

		/// <summary>
		/// 获取在线的客户端的数量<br />
		/// Get the number of clients online
		/// </summary>
		// Token: 0x17000568 RID: 1384
		// (get) Token: 0x06001A53 RID: 6739 RVA: 0x000845B1 File Offset: 0x000827B1
		public int OnlineCount
		{
			get
			{
				return this.onlineCount;
			}
		}

		/// <summary>
		/// 获取当前所有在线的客户端信息，包括IP地址和端口号信息<br />
		/// Get all current online client information, including IP address and port number information
		/// </summary>
		// Token: 0x17000569 RID: 1385
		// (get) Token: 0x06001A54 RID: 6740 RVA: 0x000845BC File Offset: 0x000827BC
		public AppSession[] GetOnlineSessions
		{
			get
			{
				object obj = this.lockOnlineClient;
				AppSession[] result;
				lock (obj)
				{
					result = this.listsOnlineClient.ToArray();
				}
				return result;
			}
		}

		/// <summary>
		/// 新增一个在线的客户端信息<br />
		/// Add an online client information
		/// </summary>
		/// <param name="session">会话内容</param>
		// Token: 0x06001A55 RID: 6741 RVA: 0x00084608 File Offset: 0x00082808
		protected void AddClient(AppSession session)
		{
			object obj = this.lockOnlineClient;
			lock (obj)
			{
				this.listsOnlineClient.Add(session);
				this.onlineCount++;
			}
		}

		/// <summary>
		/// 移除一个在线的客户端信息<br />
		/// Remove an online client message
		/// </summary>
		/// <param name="session">会话内容</param>
		/// <param name="reason">下线的原因</param>
		// Token: 0x06001A56 RID: 6742 RVA: 0x00084664 File Offset: 0x00082864
		protected void RemoveClient(AppSession session, string reason = "")
		{
			object obj = this.lockOnlineClient;
			lock (obj)
			{
				bool flag2 = this.listsOnlineClient.Remove(session);
				if (flag2)
				{
					ILogNet logNet = base.LogNet;
					if (logNet != null)
					{
						logNet.WriteDebug(this.ToString(), string.Format(StringResources.Language.ClientOfflineInfo, session.IpEndPoint) + " " + reason);
					}
					Socket workSocket = session.WorkSocket;
					if (workSocket != null)
					{
						workSocket.Close();
					}
					this.onlineCount--;
				}
			}
		}

		/// <summary>
		/// 关闭之后进行的操作
		/// </summary>
		// Token: 0x06001A57 RID: 6743 RVA: 0x00084710 File Offset: 0x00082910
		protected override void CloseAction()
		{
			base.CloseAction();
			object obj = this.lockOnlineClient;
			lock (obj)
			{
				for (int i = 0; i < this.listsOnlineClient.Count; i++)
				{
					AppSession appSession = this.listsOnlineClient[i];
					if (appSession != null)
					{
						Socket workSocket = appSession.WorkSocket;
						if (workSocket != null)
						{
							workSocket.Close();
						}
					}
				}
				this.listsOnlineClient.Clear();
			}
		}

		// Token: 0x06001A58 RID: 6744 RVA: 0x000847A4 File Offset: 0x000829A4
		private void ThreadTimerHeartCheck(object obj)
		{
			AppSession[] array = null;
			object obj2 = this.lockOnlineClient;
			lock (obj2)
			{
				array = this.listsOnlineClient.ToArray();
			}
			bool flag2 = array != null && array.Length != 0;
			if (flag2)
			{
				for (int i = 0; i < array.Length; i++)
				{
					bool flag3 = DateTime.Now - array[i].HeartTime > this.ActiveTimeSpan;
					if (flag3)
					{
						this.RemoveClient(array[i], "");
					}
				}
			}
		}

		/// <summary>
		/// 释放当前的对象
		/// </summary>
		/// <param name="disposing">是否托管对象</param>
		// Token: 0x06001A59 RID: 6745 RVA: 0x00084850 File Offset: 0x00082A50
		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				SimpleHybirdLock simpleHybirdLock = this.lock_trusted_clients;
				if (simpleHybirdLock != null)
				{
					simpleHybirdLock.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		/// <inheritdoc />
		// Token: 0x06001A5A RID: 6746 RVA: 0x0008487F File Offset: 0x00082A7F
		public override string ToString()
		{
			return string.Format("NetworkDataServerBase[{0}]", base.Port);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read(System.String,System.UInt16)" />
		// Token: 0x06001A5B RID: 6747 RVA: 0x0000ABFE File Offset: 0x00008DFE
		[HslMqttApi("ReadByteArray", "")]
		public virtual OperateResult<byte[]> Read(string address, ushort length)
		{
			return new OperateResult<byte[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Byte[])" />
		// Token: 0x06001A5C RID: 6748 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteByteArray", "")]
		public virtual OperateResult Write(string address, byte[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String,System.UInt16)" />
		// Token: 0x06001A5D RID: 6749 RVA: 0x0000AC20 File Offset: 0x00008E20
		[HslMqttApi("ReadBoolArray", "")]
		public virtual OperateResult<bool[]> ReadBool(string address, ushort length)
		{
			return new OperateResult<bool[]>(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBool(System.String)" />
		// Token: 0x06001A5E RID: 6750 RVA: 0x00084896 File Offset: 0x00082A96
		[HslMqttApi("ReadBool", "")]
		public virtual OperateResult<bool> ReadBool(string address)
		{
			return ByteTransformHelper.GetResultFromArray<bool>(this.ReadBool(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean[])" />
		// Token: 0x06001A5F RID: 6751 RVA: 0x0000AC0F File Offset: 0x00008E0F
		[HslMqttApi("WriteBoolArray", "")]
		public virtual OperateResult Write(string address, bool[] value)
		{
			return new OperateResult(StringResources.Language.NotSupportedFunction);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Boolean)" />
		// Token: 0x06001A60 RID: 6752 RVA: 0x000848A5 File Offset: 0x00082AA5
		[HslMqttApi("WriteBool", "")]
		public virtual OperateResult Write(string address, bool value)
		{
			return this.Write(address, new bool[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadCustomer``1(System.String)" />
		// Token: 0x06001A61 RID: 6753 RVA: 0x000848B8 File Offset: 0x00082AB8
		public OperateResult<T> ReadCustomer<T>(string address) where T : IDataTransfer, new()
		{
			OperateResult<T> operateResult = new OperateResult<T>();
			T content = Activator.CreateInstance<T>();
			OperateResult<byte[]> operateResult2 = this.Read(address, content.ReadCount);
			bool isSuccess = operateResult2.IsSuccess;
			if (isSuccess)
			{
				content.ParseSource(operateResult2.Content);
				operateResult.Content = content;
				operateResult.IsSuccess = true;
			}
			else
			{
				operateResult.ErrorCode = operateResult2.ErrorCode;
				operateResult.Message = operateResult2.Message;
			}
			return operateResult;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomer``1(System.String,``0)" />
		// Token: 0x06001A62 RID: 6754 RVA: 0x0008493C File Offset: 0x00082B3C
		public OperateResult WriteCustomer<T>(string address, T data) where T : IDataTransfer, new()
		{
			return this.Write(address, data.ToSource());
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Read``1" />
		// Token: 0x06001A63 RID: 6755 RVA: 0x00084952 File Offset: 0x00082B52
		public virtual OperateResult<T> Read<T>() where T : class, new()
		{
			return HslReflectionHelper.Read<T>(this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write``1(``0)" />
		// Token: 0x06001A64 RID: 6756 RVA: 0x0008495A File Offset: 0x00082B5A
		public virtual OperateResult Write<T>(T data) where T : class, new()
		{
			return HslReflectionHelper.Write<T>(data, this);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String)" />
		// Token: 0x06001A65 RID: 6757 RVA: 0x00084963 File Offset: 0x00082B63
		[HslMqttApi("ReadInt16", "")]
		public OperateResult<short> ReadInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<short>(this.ReadInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16(System.String,System.UInt16)" />
		// Token: 0x06001A66 RID: 6758 RVA: 0x00084974 File Offset: 0x00082B74
		[HslMqttApi("ReadInt16Array", "")]
		public virtual OperateResult<short[]> ReadInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<short[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String)" />
		// Token: 0x06001A67 RID: 6759 RVA: 0x000849BB File Offset: 0x00082BBB
		[HslMqttApi("ReadUInt16", "")]
		public OperateResult<ushort> ReadUInt16(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ushort>(this.ReadUInt16(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16(System.String,System.UInt16)" />
		// Token: 0x06001A68 RID: 6760 RVA: 0x000849CC File Offset: 0x00082BCC
		[HslMqttApi("ReadUInt16Array", "")]
		public virtual OperateResult<ushort[]> ReadUInt16(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ushort[]>(this.Read(address, length * this.WordLength), (byte[] m) => this.ByteTransform.TransUInt16(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String)" />
		// Token: 0x06001A69 RID: 6761 RVA: 0x00084A13 File Offset: 0x00082C13
		[HslMqttApi("ReadInt32", "")]
		public OperateResult<int> ReadInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<int>(this.ReadInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32(System.String,System.UInt16)" />
		// Token: 0x06001A6A RID: 6762 RVA: 0x00084A24 File Offset: 0x00082C24
		[HslMqttApi("ReadInt32Array", "")]
		public virtual OperateResult<int[]> ReadInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<int[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String)" />
		// Token: 0x06001A6B RID: 6763 RVA: 0x00084A6D File Offset: 0x00082C6D
		[HslMqttApi("ReadUInt32", "")]
		public OperateResult<uint> ReadUInt32(string address)
		{
			return ByteTransformHelper.GetResultFromArray<uint>(this.ReadUInt32(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32(System.String,System.UInt16)" />
		// Token: 0x06001A6C RID: 6764 RVA: 0x00084A7C File Offset: 0x00082C7C
		[HslMqttApi("ReadUInt32Array", "")]
		public virtual OperateResult<uint[]> ReadUInt32(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<uint[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransUInt32(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String)" />
		// Token: 0x06001A6D RID: 6765 RVA: 0x00084AC5 File Offset: 0x00082CC5
		[HslMqttApi("ReadFloat", "")]
		public OperateResult<float> ReadFloat(string address)
		{
			return ByteTransformHelper.GetResultFromArray<float>(this.ReadFloat(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloat(System.String,System.UInt16)" />
		// Token: 0x06001A6E RID: 6766 RVA: 0x00084AD4 File Offset: 0x00082CD4
		[HslMqttApi("ReadFloatArray", "")]
		public virtual OperateResult<float[]> ReadFloat(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<float[]>(this.Read(address, length * this.WordLength * 2), (byte[] m) => this.ByteTransform.TransSingle(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String)" />
		// Token: 0x06001A6F RID: 6767 RVA: 0x00084B1D File Offset: 0x00082D1D
		[HslMqttApi("ReadInt64", "")]
		public OperateResult<long> ReadInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<long>(this.ReadInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64(System.String,System.UInt16)" />
		// Token: 0x06001A70 RID: 6768 RVA: 0x00084B2C File Offset: 0x00082D2C
		[HslMqttApi("ReadInt64Array", "")]
		public virtual OperateResult<long[]> ReadInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<long[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String)" />
		// Token: 0x06001A71 RID: 6769 RVA: 0x00084B75 File Offset: 0x00082D75
		[HslMqttApi("ReadUInt64", "")]
		public OperateResult<ulong> ReadUInt64(string address)
		{
			return ByteTransformHelper.GetResultFromArray<ulong>(this.ReadUInt64(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64(System.String,System.UInt16)" />
		// Token: 0x06001A72 RID: 6770 RVA: 0x00084B84 File Offset: 0x00082D84
		[HslMqttApi("ReadUInt64Array", "")]
		public virtual OperateResult<ulong[]> ReadUInt64(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<ulong[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransUInt64(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String)" />
		// Token: 0x06001A73 RID: 6771 RVA: 0x00084BCD File Offset: 0x00082DCD
		[HslMqttApi("ReadDouble", "")]
		public OperateResult<double> ReadDouble(string address)
		{
			return ByteTransformHelper.GetResultFromArray<double>(this.ReadDouble(address, 1));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDouble(System.String,System.UInt16)" />
		// Token: 0x06001A74 RID: 6772 RVA: 0x00084BDC File Offset: 0x00082DDC
		[HslMqttApi("ReadDoubleArray", "")]
		public virtual OperateResult<double[]> ReadDouble(string address, ushort length)
		{
			return ByteTransformHelper.GetResultFromBytes<double[]>(this.Read(address, length * this.WordLength * 4), (byte[] m) => this.ByteTransform.TransDouble(m, 0, (int)length));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16)" />
		// Token: 0x06001A75 RID: 6773 RVA: 0x00084C25 File Offset: 0x00082E25
		[HslMqttApi("ReadString", "")]
		public OperateResult<string> ReadString(string address, ushort length)
		{
			return this.ReadString(address, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadString(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x06001A76 RID: 6774 RVA: 0x00084C34 File Offset: 0x00082E34
		public virtual OperateResult<string> ReadString(string address, ushort length, Encoding encoding)
		{
			return ByteTransformHelper.GetResultFromBytes<string>(this.Read(address, length), (byte[] m) => this.ByteTransform.TransString(m, 0, m.Length, encoding));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16[])" />
		// Token: 0x06001A77 RID: 6775 RVA: 0x00084C6E File Offset: 0x00082E6E
		[HslMqttApi("WriteInt16Array", "")]
		public virtual OperateResult Write(string address, short[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int16)" />
		// Token: 0x06001A78 RID: 6776 RVA: 0x00084C83 File Offset: 0x00082E83
		[HslMqttApi("WriteInt16", "")]
		public virtual OperateResult Write(string address, short value)
		{
			return this.Write(address, new short[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16[])" />
		// Token: 0x06001A79 RID: 6777 RVA: 0x00084C96 File Offset: 0x00082E96
		[HslMqttApi("WriteUInt16Array", "")]
		public virtual OperateResult Write(string address, ushort[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt16)" />
		// Token: 0x06001A7A RID: 6778 RVA: 0x00084CAB File Offset: 0x00082EAB
		[HslMqttApi("WriteUInt16", "")]
		public virtual OperateResult Write(string address, ushort value)
		{
			return this.Write(address, new ushort[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32[])" />
		// Token: 0x06001A7B RID: 6779 RVA: 0x00084CBE File Offset: 0x00082EBE
		[HslMqttApi("WriteInt32Array", "")]
		public virtual OperateResult Write(string address, int[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int32)" />
		// Token: 0x06001A7C RID: 6780 RVA: 0x00084CD3 File Offset: 0x00082ED3
		[HslMqttApi("WriteInt32", "")]
		public OperateResult Write(string address, int value)
		{
			return this.Write(address, new int[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32[])" />
		// Token: 0x06001A7D RID: 6781 RVA: 0x00084CE6 File Offset: 0x00082EE6
		[HslMqttApi("WriteUInt32Array", "")]
		public virtual OperateResult Write(string address, uint[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt32)" />
		// Token: 0x06001A7E RID: 6782 RVA: 0x00084CFB File Offset: 0x00082EFB
		[HslMqttApi("WriteUInt32", "")]
		public OperateResult Write(string address, uint value)
		{
			return this.Write(address, new uint[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single[])" />
		// Token: 0x06001A7F RID: 6783 RVA: 0x00084D0E File Offset: 0x00082F0E
		[HslMqttApi("WriteFloatArray", "")]
		public virtual OperateResult Write(string address, float[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Single)" />
		// Token: 0x06001A80 RID: 6784 RVA: 0x00084D23 File Offset: 0x00082F23
		[HslMqttApi("WriteFloat", "")]
		public OperateResult Write(string address, float value)
		{
			return this.Write(address, new float[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64[])" />
		// Token: 0x06001A81 RID: 6785 RVA: 0x00084D36 File Offset: 0x00082F36
		[HslMqttApi("WriteInt64Array", "")]
		public virtual OperateResult Write(string address, long[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Int64)" />
		// Token: 0x06001A82 RID: 6786 RVA: 0x00084D4B File Offset: 0x00082F4B
		[HslMqttApi("WriteInt64", "")]
		public OperateResult Write(string address, long value)
		{
			return this.Write(address, new long[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64[])" />
		// Token: 0x06001A83 RID: 6787 RVA: 0x00084D5E File Offset: 0x00082F5E
		[HslMqttApi("WriteUInt64Array", "")]
		public virtual OperateResult Write(string address, ulong[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.UInt64)" />
		// Token: 0x06001A84 RID: 6788 RVA: 0x00084D73 File Offset: 0x00082F73
		[HslMqttApi("WriteUInt64", "")]
		public OperateResult Write(string address, ulong value)
		{
			return this.Write(address, new ulong[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double[])" />
		// Token: 0x06001A85 RID: 6789 RVA: 0x00084D86 File Offset: 0x00082F86
		[HslMqttApi("WriteDoubleArray", "")]
		public virtual OperateResult Write(string address, double[] values)
		{
			return this.Write(address, this.ByteTransform.TransByte(values));
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.Double)" />
		// Token: 0x06001A86 RID: 6790 RVA: 0x00084D9B File Offset: 0x00082F9B
		[HslMqttApi("WriteDouble", "")]
		public OperateResult Write(string address, double value)
		{
			return this.Write(address, new double[]
			{
				value
			});
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String)" />
		// Token: 0x06001A87 RID: 6791 RVA: 0x00084DAE File Offset: 0x00082FAE
		[HslMqttApi("WriteString", "")]
		public virtual OperateResult Write(string address, string value)
		{
			return this.Write(address, value, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32)" />
		// Token: 0x06001A88 RID: 6792 RVA: 0x00084DBD File Offset: 0x00082FBD
		public virtual OperateResult Write(string address, string value, int length)
		{
			return this.Write(address, value, length, Encoding.ASCII);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x06001A89 RID: 6793 RVA: 0x00084DD0 File Offset: 0x00082FD0
		public virtual OperateResult Write(string address, string value, Encoding encoding)
		{
			byte[] array = this.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Write(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x06001A8A RID: 6794 RVA: 0x00084E0C File Offset: 0x0008300C
		public virtual OperateResult Write(string address, string value, int length, Encoding encoding)
		{
			byte[] array = this.ByteTransform.TransByte(value, encoding);
			bool flag = this.WordLength == 1;
			if (flag)
			{
				array = SoftBasic.ArrayExpandToLengthEven<byte>(array);
			}
			array = SoftBasic.ArrayExpandToLength<byte>(array, length);
			return this.Write(address, array);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x06001A8B RID: 6795 RVA: 0x0000B1ED File Offset: 0x000093ED
		[HslMqttApi("WaitBool", "")]
		public OperateResult<TimeSpan> Wait(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x06001A8C RID: 6796 RVA: 0x0000B1FA File Offset: 0x000093FA
		[HslMqttApi("WaitInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x06001A8D RID: 6797 RVA: 0x0000B207 File Offset: 0x00009407
		[HslMqttApi("WaitUInt16", "")]
		public OperateResult<TimeSpan> Wait(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x06001A8E RID: 6798 RVA: 0x0000B214 File Offset: 0x00009414
		[HslMqttApi("WaitInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x06001A8F RID: 6799 RVA: 0x0000B221 File Offset: 0x00009421
		[HslMqttApi("WaitUInt32", "")]
		public OperateResult<TimeSpan> Wait(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x06001A90 RID: 6800 RVA: 0x0000B22E File Offset: 0x0000942E
		[HslMqttApi("WaitInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x06001A91 RID: 6801 RVA: 0x0000B23B File Offset: 0x0000943B
		[HslMqttApi("WaitUInt64", "")]
		public OperateResult<TimeSpan> Wait(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			return ReadWriteNetHelper.Wait(this, address, waitValue, readInterval, waitTimeout);
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Boolean,System.Int32,System.Int32)" />
		// Token: 0x06001A92 RID: 6802 RVA: 0x00084E54 File Offset: 0x00083054
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, bool waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__108 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__108();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__108>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int16,System.Int32,System.Int32)" />
		// Token: 0x06001A93 RID: 6803 RVA: 0x00084EB8 File Offset: 0x000830B8
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, short waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__109 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__109();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__109>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt16,System.Int32,System.Int32)" />
		// Token: 0x06001A94 RID: 6804 RVA: 0x00084F1C File Offset: 0x0008311C
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ushort waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__110 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__110();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__110>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int32,System.Int32,System.Int32)" />
		// Token: 0x06001A95 RID: 6805 RVA: 0x00084F80 File Offset: 0x00083180
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, int waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__111 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__111();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__111>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt32,System.Int32,System.Int32)" />
		// Token: 0x06001A96 RID: 6806 RVA: 0x00084FE4 File Offset: 0x000831E4
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, uint waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__112 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__112();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__112>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.Int64,System.Int32,System.Int32)" />
		// Token: 0x06001A97 RID: 6807 RVA: 0x00085048 File Offset: 0x00083248
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, long waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__113 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__113();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__113>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.Wait(System.String,System.UInt64,System.Int32,System.Int32)" />
		// Token: 0x06001A98 RID: 6808 RVA: 0x000850AC File Offset: 0x000832AC
		[DebuggerStepThrough]
		public Task<OperateResult<TimeSpan>> WaitAsync(string address, ulong waitValue, int readInterval = 100, int waitTimeout = -1)
		{
			NetworkDataServerBase.<WaitAsync>d__114 <WaitAsync>d__ = new NetworkDataServerBase.<WaitAsync>d__114();
			<WaitAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<TimeSpan>>.Create();
			<WaitAsync>d__.<>4__this = this;
			<WaitAsync>d__.address = address;
			<WaitAsync>d__.waitValue = waitValue;
			<WaitAsync>d__.readInterval = readInterval;
			<WaitAsync>d__.waitTimeout = waitTimeout;
			<WaitAsync>d__.<>1__state = -1;
			<WaitAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WaitAsync>d__114>(ref <WaitAsync>d__);
			return <WaitAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync(System.String,System.UInt16)" />
		// Token: 0x06001A99 RID: 6809 RVA: 0x00085110 File Offset: 0x00083310
		[DebuggerStepThrough]
		public virtual Task<OperateResult<byte[]>> ReadAsync(string address, ushort length)
		{
			NetworkDataServerBase.<ReadAsync>d__115 <ReadAsync>d__ = new NetworkDataServerBase.<ReadAsync>d__115();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<byte[]>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.address = address;
			<ReadAsync>d__.length = length;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadAsync>d__115>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Byte[])" />
		// Token: 0x06001A9A RID: 6810 RVA: 0x00085164 File Offset: 0x00083364
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, byte[] value)
		{
			NetworkDataServerBase.<WriteAsync>d__116 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__116();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__116>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String,System.UInt16)" />
		// Token: 0x06001A9B RID: 6811 RVA: 0x000851B8 File Offset: 0x000833B8
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool[]>> ReadBoolAsync(string address, ushort length)
		{
			NetworkDataServerBase.<ReadBoolAsync>d__117 <ReadBoolAsync>d__ = new NetworkDataServerBase.<ReadBoolAsync>d__117();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool[]>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.length = length;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadBoolAsync>d__117>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadBoolAsync(System.String)" />
		// Token: 0x06001A9C RID: 6812 RVA: 0x0008520C File Offset: 0x0008340C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<bool>> ReadBoolAsync(string address)
		{
			NetworkDataServerBase.<ReadBoolAsync>d__118 <ReadBoolAsync>d__ = new NetworkDataServerBase.<ReadBoolAsync>d__118();
			<ReadBoolAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<bool>>.Create();
			<ReadBoolAsync>d__.<>4__this = this;
			<ReadBoolAsync>d__.address = address;
			<ReadBoolAsync>d__.<>1__state = -1;
			<ReadBoolAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadBoolAsync>d__118>(ref <ReadBoolAsync>d__);
			return <ReadBoolAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean[])" />
		// Token: 0x06001A9D RID: 6813 RVA: 0x00085258 File Offset: 0x00083458
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool[] value)
		{
			NetworkDataServerBase.<WriteAsync>d__119 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__119();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__119>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Boolean)" />
		// Token: 0x06001A9E RID: 6814 RVA: 0x000852AC File Offset: 0x000834AC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, bool value)
		{
			NetworkDataServerBase.<WriteAsync>d__120 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__120();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__120>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x06001A9F RID: 6815 RVA: 0x00085300 File Offset: 0x00083500
		[DebuggerStepThrough]
		public Task<OperateResult<T>> ReadCustomerAsync<T>(string address) where T : IDataTransfer, new()
		{
			NetworkDataServerBase.<ReadCustomerAsync>d__121<T> <ReadCustomerAsync>d__ = new NetworkDataServerBase.<ReadCustomerAsync>d__121<T>();
			<ReadCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadCustomerAsync>d__.<>4__this = this;
			<ReadCustomerAsync>d__.address = address;
			<ReadCustomerAsync>d__.<>1__state = -1;
			<ReadCustomerAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadCustomerAsync>d__121<T>>(ref <ReadCustomerAsync>d__);
			return <ReadCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteCustomerAsync``1(System.String,``0)" />
		// Token: 0x06001AA0 RID: 6816 RVA: 0x0008534C File Offset: 0x0008354C
		[DebuggerStepThrough]
		public Task<OperateResult> WriteCustomerAsync<T>(string address, T data) where T : IDataTransfer, new()
		{
			NetworkDataServerBase.<WriteCustomerAsync>d__122<T> <WriteCustomerAsync>d__ = new NetworkDataServerBase.<WriteCustomerAsync>d__122<T>();
			<WriteCustomerAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteCustomerAsync>d__.<>4__this = this;
			<WriteCustomerAsync>d__.address = address;
			<WriteCustomerAsync>d__.data = data;
			<WriteCustomerAsync>d__.<>1__state = -1;
			<WriteCustomerAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteCustomerAsync>d__122<T>>(ref <WriteCustomerAsync>d__);
			return <WriteCustomerAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadAsync``1" />
		// Token: 0x06001AA1 RID: 6817 RVA: 0x000853A0 File Offset: 0x000835A0
		[DebuggerStepThrough]
		public virtual Task<OperateResult<T>> ReadAsync<T>() where T : class, new()
		{
			NetworkDataServerBase.<ReadAsync>d__123<T> <ReadAsync>d__ = new NetworkDataServerBase.<ReadAsync>d__123<T>();
			<ReadAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<T>>.Create();
			<ReadAsync>d__.<>4__this = this;
			<ReadAsync>d__.<>1__state = -1;
			<ReadAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadAsync>d__123<T>>(ref <ReadAsync>d__);
			return <ReadAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync``1(``0)" />
		// Token: 0x06001AA2 RID: 6818 RVA: 0x000853E4 File Offset: 0x000835E4
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync<T>(T data) where T : class, new()
		{
			NetworkDataServerBase.<WriteAsync>d__124<T> <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__124<T>();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.data = data;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__124<T>>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String)" />
		// Token: 0x06001AA3 RID: 6819 RVA: 0x00085430 File Offset: 0x00083630
		[DebuggerStepThrough]
		public Task<OperateResult<short>> ReadInt16Async(string address)
		{
			NetworkDataServerBase.<ReadInt16Async>d__125 <ReadInt16Async>d__ = new NetworkDataServerBase.<ReadInt16Async>d__125();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadInt16Async>d__125>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt16Async(System.String,System.UInt16)" />
		// Token: 0x06001AA4 RID: 6820 RVA: 0x0008547C File Offset: 0x0008367C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<short[]>> ReadInt16Async(string address, ushort length)
		{
			NetworkDataServerBase.<ReadInt16Async>d__126 <ReadInt16Async>d__ = new NetworkDataServerBase.<ReadInt16Async>d__126();
			<ReadInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<short[]>>.Create();
			<ReadInt16Async>d__.<>4__this = this;
			<ReadInt16Async>d__.address = address;
			<ReadInt16Async>d__.length = length;
			<ReadInt16Async>d__.<>1__state = -1;
			<ReadInt16Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadInt16Async>d__126>(ref <ReadInt16Async>d__);
			return <ReadInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String)" />
		// Token: 0x06001AA5 RID: 6821 RVA: 0x000854D0 File Offset: 0x000836D0
		[DebuggerStepThrough]
		public Task<OperateResult<ushort>> ReadUInt16Async(string address)
		{
			NetworkDataServerBase.<ReadUInt16Async>d__127 <ReadUInt16Async>d__ = new NetworkDataServerBase.<ReadUInt16Async>d__127();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadUInt16Async>d__127>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt16Async(System.String,System.UInt16)" />
		// Token: 0x06001AA6 RID: 6822 RVA: 0x0008551C File Offset: 0x0008371C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ushort[]>> ReadUInt16Async(string address, ushort length)
		{
			NetworkDataServerBase.<ReadUInt16Async>d__128 <ReadUInt16Async>d__ = new NetworkDataServerBase.<ReadUInt16Async>d__128();
			<ReadUInt16Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ushort[]>>.Create();
			<ReadUInt16Async>d__.<>4__this = this;
			<ReadUInt16Async>d__.address = address;
			<ReadUInt16Async>d__.length = length;
			<ReadUInt16Async>d__.<>1__state = -1;
			<ReadUInt16Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadUInt16Async>d__128>(ref <ReadUInt16Async>d__);
			return <ReadUInt16Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String)" />
		// Token: 0x06001AA7 RID: 6823 RVA: 0x00085570 File Offset: 0x00083770
		[DebuggerStepThrough]
		public Task<OperateResult<int>> ReadInt32Async(string address)
		{
			NetworkDataServerBase.<ReadInt32Async>d__129 <ReadInt32Async>d__ = new NetworkDataServerBase.<ReadInt32Async>d__129();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadInt32Async>d__129>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt32Async(System.String,System.UInt16)" />
		// Token: 0x06001AA8 RID: 6824 RVA: 0x000855BC File Offset: 0x000837BC
		[DebuggerStepThrough]
		public virtual Task<OperateResult<int[]>> ReadInt32Async(string address, ushort length)
		{
			NetworkDataServerBase.<ReadInt32Async>d__130 <ReadInt32Async>d__ = new NetworkDataServerBase.<ReadInt32Async>d__130();
			<ReadInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<int[]>>.Create();
			<ReadInt32Async>d__.<>4__this = this;
			<ReadInt32Async>d__.address = address;
			<ReadInt32Async>d__.length = length;
			<ReadInt32Async>d__.<>1__state = -1;
			<ReadInt32Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadInt32Async>d__130>(ref <ReadInt32Async>d__);
			return <ReadInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String)" />
		// Token: 0x06001AA9 RID: 6825 RVA: 0x00085610 File Offset: 0x00083810
		[DebuggerStepThrough]
		public Task<OperateResult<uint>> ReadUInt32Async(string address)
		{
			NetworkDataServerBase.<ReadUInt32Async>d__131 <ReadUInt32Async>d__ = new NetworkDataServerBase.<ReadUInt32Async>d__131();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadUInt32Async>d__131>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt32Async(System.String,System.UInt16)" />
		// Token: 0x06001AAA RID: 6826 RVA: 0x0008565C File Offset: 0x0008385C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<uint[]>> ReadUInt32Async(string address, ushort length)
		{
			NetworkDataServerBase.<ReadUInt32Async>d__132 <ReadUInt32Async>d__ = new NetworkDataServerBase.<ReadUInt32Async>d__132();
			<ReadUInt32Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<uint[]>>.Create();
			<ReadUInt32Async>d__.<>4__this = this;
			<ReadUInt32Async>d__.address = address;
			<ReadUInt32Async>d__.length = length;
			<ReadUInt32Async>d__.<>1__state = -1;
			<ReadUInt32Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadUInt32Async>d__132>(ref <ReadUInt32Async>d__);
			return <ReadUInt32Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String)" />
		// Token: 0x06001AAB RID: 6827 RVA: 0x000856B0 File Offset: 0x000838B0
		[DebuggerStepThrough]
		public Task<OperateResult<float>> ReadFloatAsync(string address)
		{
			NetworkDataServerBase.<ReadFloatAsync>d__133 <ReadFloatAsync>d__ = new NetworkDataServerBase.<ReadFloatAsync>d__133();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadFloatAsync>d__133>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadFloatAsync(System.String,System.UInt16)" />
		// Token: 0x06001AAC RID: 6828 RVA: 0x000856FC File Offset: 0x000838FC
		[DebuggerStepThrough]
		public virtual Task<OperateResult<float[]>> ReadFloatAsync(string address, ushort length)
		{
			NetworkDataServerBase.<ReadFloatAsync>d__134 <ReadFloatAsync>d__ = new NetworkDataServerBase.<ReadFloatAsync>d__134();
			<ReadFloatAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<float[]>>.Create();
			<ReadFloatAsync>d__.<>4__this = this;
			<ReadFloatAsync>d__.address = address;
			<ReadFloatAsync>d__.length = length;
			<ReadFloatAsync>d__.<>1__state = -1;
			<ReadFloatAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadFloatAsync>d__134>(ref <ReadFloatAsync>d__);
			return <ReadFloatAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String)" />
		// Token: 0x06001AAD RID: 6829 RVA: 0x00085750 File Offset: 0x00083950
		[DebuggerStepThrough]
		public Task<OperateResult<long>> ReadInt64Async(string address)
		{
			NetworkDataServerBase.<ReadInt64Async>d__135 <ReadInt64Async>d__ = new NetworkDataServerBase.<ReadInt64Async>d__135();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadInt64Async>d__135>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadInt64Async(System.String,System.UInt16)" />
		// Token: 0x06001AAE RID: 6830 RVA: 0x0008579C File Offset: 0x0008399C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<long[]>> ReadInt64Async(string address, ushort length)
		{
			NetworkDataServerBase.<ReadInt64Async>d__136 <ReadInt64Async>d__ = new NetworkDataServerBase.<ReadInt64Async>d__136();
			<ReadInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<long[]>>.Create();
			<ReadInt64Async>d__.<>4__this = this;
			<ReadInt64Async>d__.address = address;
			<ReadInt64Async>d__.length = length;
			<ReadInt64Async>d__.<>1__state = -1;
			<ReadInt64Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadInt64Async>d__136>(ref <ReadInt64Async>d__);
			return <ReadInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String)" />
		// Token: 0x06001AAF RID: 6831 RVA: 0x000857F0 File Offset: 0x000839F0
		[DebuggerStepThrough]
		public Task<OperateResult<ulong>> ReadUInt64Async(string address)
		{
			NetworkDataServerBase.<ReadUInt64Async>d__137 <ReadUInt64Async>d__ = new NetworkDataServerBase.<ReadUInt64Async>d__137();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadUInt64Async>d__137>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadUInt64Async(System.String,System.UInt16)" />
		// Token: 0x06001AB0 RID: 6832 RVA: 0x0008583C File Offset: 0x00083A3C
		[DebuggerStepThrough]
		public virtual Task<OperateResult<ulong[]>> ReadUInt64Async(string address, ushort length)
		{
			NetworkDataServerBase.<ReadUInt64Async>d__138 <ReadUInt64Async>d__ = new NetworkDataServerBase.<ReadUInt64Async>d__138();
			<ReadUInt64Async>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<ulong[]>>.Create();
			<ReadUInt64Async>d__.<>4__this = this;
			<ReadUInt64Async>d__.address = address;
			<ReadUInt64Async>d__.length = length;
			<ReadUInt64Async>d__.<>1__state = -1;
			<ReadUInt64Async>d__.<>t__builder.Start<NetworkDataServerBase.<ReadUInt64Async>d__138>(ref <ReadUInt64Async>d__);
			return <ReadUInt64Async>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String)" />
		// Token: 0x06001AB1 RID: 6833 RVA: 0x00085890 File Offset: 0x00083A90
		[DebuggerStepThrough]
		public Task<OperateResult<double>> ReadDoubleAsync(string address)
		{
			NetworkDataServerBase.<ReadDoubleAsync>d__139 <ReadDoubleAsync>d__ = new NetworkDataServerBase.<ReadDoubleAsync>d__139();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadDoubleAsync>d__139>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadDoubleAsync(System.String,System.UInt16)" />
		// Token: 0x06001AB2 RID: 6834 RVA: 0x000858DC File Offset: 0x00083ADC
		[DebuggerStepThrough]
		public virtual Task<OperateResult<double[]>> ReadDoubleAsync(string address, ushort length)
		{
			NetworkDataServerBase.<ReadDoubleAsync>d__140 <ReadDoubleAsync>d__ = new NetworkDataServerBase.<ReadDoubleAsync>d__140();
			<ReadDoubleAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<double[]>>.Create();
			<ReadDoubleAsync>d__.<>4__this = this;
			<ReadDoubleAsync>d__.address = address;
			<ReadDoubleAsync>d__.length = length;
			<ReadDoubleAsync>d__.<>1__state = -1;
			<ReadDoubleAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadDoubleAsync>d__140>(ref <ReadDoubleAsync>d__);
			return <ReadDoubleAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16)" />
		// Token: 0x06001AB3 RID: 6835 RVA: 0x00085930 File Offset: 0x00083B30
		[DebuggerStepThrough]
		public Task<OperateResult<string>> ReadStringAsync(string address, ushort length)
		{
			NetworkDataServerBase.<ReadStringAsync>d__141 <ReadStringAsync>d__ = new NetworkDataServerBase.<ReadStringAsync>d__141();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadStringAsync>d__141>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.ReadStringAsync(System.String,System.UInt16,System.Text.Encoding)" />
		// Token: 0x06001AB4 RID: 6836 RVA: 0x00085984 File Offset: 0x00083B84
		[DebuggerStepThrough]
		public virtual Task<OperateResult<string>> ReadStringAsync(string address, ushort length, Encoding encoding)
		{
			NetworkDataServerBase.<ReadStringAsync>d__142 <ReadStringAsync>d__ = new NetworkDataServerBase.<ReadStringAsync>d__142();
			<ReadStringAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult<string>>.Create();
			<ReadStringAsync>d__.<>4__this = this;
			<ReadStringAsync>d__.address = address;
			<ReadStringAsync>d__.length = length;
			<ReadStringAsync>d__.encoding = encoding;
			<ReadStringAsync>d__.<>1__state = -1;
			<ReadStringAsync>d__.<>t__builder.Start<NetworkDataServerBase.<ReadStringAsync>d__142>(ref <ReadStringAsync>d__);
			return <ReadStringAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16[])" />
		// Token: 0x06001AB5 RID: 6837 RVA: 0x000859E0 File Offset: 0x00083BE0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__143 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__143();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__143>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int16)" />
		// Token: 0x06001AB6 RID: 6838 RVA: 0x00085A34 File Offset: 0x00083C34
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, short value)
		{
			NetworkDataServerBase.<WriteAsync>d__144 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__144();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__144>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16[])" />
		// Token: 0x06001AB7 RID: 6839 RVA: 0x00085A88 File Offset: 0x00083C88
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__145 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__145();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__145>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt16)" />
		// Token: 0x06001AB8 RID: 6840 RVA: 0x00085ADC File Offset: 0x00083CDC
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ushort value)
		{
			NetworkDataServerBase.<WriteAsync>d__146 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__146();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__146>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32[])" />
		// Token: 0x06001AB9 RID: 6841 RVA: 0x00085B30 File Offset: 0x00083D30
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, int[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__147 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__147();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__147>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int32)" />
		// Token: 0x06001ABA RID: 6842 RVA: 0x00085B84 File Offset: 0x00083D84
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, int value)
		{
			NetworkDataServerBase.<WriteAsync>d__148 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__148();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__148>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32[])" />
		// Token: 0x06001ABB RID: 6843 RVA: 0x00085BD8 File Offset: 0x00083DD8
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, uint[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__149 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__149();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__149>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt32)" />
		// Token: 0x06001ABC RID: 6844 RVA: 0x00085C2C File Offset: 0x00083E2C
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, uint value)
		{
			NetworkDataServerBase.<WriteAsync>d__150 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__150();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__150>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single[])" />
		// Token: 0x06001ABD RID: 6845 RVA: 0x00085C80 File Offset: 0x00083E80
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, float[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__151 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__151();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__151>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Single)" />
		// Token: 0x06001ABE RID: 6846 RVA: 0x00085CD4 File Offset: 0x00083ED4
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, float value)
		{
			NetworkDataServerBase.<WriteAsync>d__152 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__152();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__152>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64[])" />
		// Token: 0x06001ABF RID: 6847 RVA: 0x00085D28 File Offset: 0x00083F28
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, long[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__153 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__153();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__153>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Int64)" />
		// Token: 0x06001AC0 RID: 6848 RVA: 0x00085D7C File Offset: 0x00083F7C
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, long value)
		{
			NetworkDataServerBase.<WriteAsync>d__154 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__154();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__154>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64[])" />
		// Token: 0x06001AC1 RID: 6849 RVA: 0x00085DD0 File Offset: 0x00083FD0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, ulong[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__155 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__155();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__155>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.UInt64)" />
		// Token: 0x06001AC2 RID: 6850 RVA: 0x00085E24 File Offset: 0x00084024
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, ulong value)
		{
			NetworkDataServerBase.<WriteAsync>d__156 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__156();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__156>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double[])" />
		// Token: 0x06001AC3 RID: 6851 RVA: 0x00085E78 File Offset: 0x00084078
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, double[] values)
		{
			NetworkDataServerBase.<WriteAsync>d__157 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__157();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.values = values;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__157>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.Double)" />
		// Token: 0x06001AC4 RID: 6852 RVA: 0x00085ECC File Offset: 0x000840CC
		[DebuggerStepThrough]
		public Task<OperateResult> WriteAsync(string address, double value)
		{
			NetworkDataServerBase.<WriteAsync>d__158 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__158();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__158>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String)" />
		// Token: 0x06001AC5 RID: 6853 RVA: 0x00085F20 File Offset: 0x00084120
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value)
		{
			NetworkDataServerBase.<WriteAsync>d__159 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__159();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__159>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Text.Encoding)" />
		// Token: 0x06001AC6 RID: 6854 RVA: 0x00085F74 File Offset: 0x00084174
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, Encoding encoding)
		{
			NetworkDataServerBase.<WriteAsync>d__160 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__160();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__160>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32)" />
		// Token: 0x06001AC7 RID: 6855 RVA: 0x00085FD0 File Offset: 0x000841D0
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length)
		{
			NetworkDataServerBase.<WriteAsync>d__161 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__161();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__161>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		/// <inheritdoc cref="M:HslCommunication.Core.IReadWriteNet.WriteAsync(System.String,System.String,System.Int32,System.Text.Encoding)" />
		// Token: 0x06001AC8 RID: 6856 RVA: 0x0008602C File Offset: 0x0008422C
		[DebuggerStepThrough]
		public virtual Task<OperateResult> WriteAsync(string address, string value, int length, Encoding encoding)
		{
			NetworkDataServerBase.<WriteAsync>d__162 <WriteAsync>d__ = new NetworkDataServerBase.<WriteAsync>d__162();
			<WriteAsync>d__.<>t__builder = AsyncTaskMethodBuilder<OperateResult>.Create();
			<WriteAsync>d__.<>4__this = this;
			<WriteAsync>d__.address = address;
			<WriteAsync>d__.value = value;
			<WriteAsync>d__.length = length;
			<WriteAsync>d__.encoding = encoding;
			<WriteAsync>d__.<>1__state = -1;
			<WriteAsync>d__.<>t__builder.Start<NetworkDataServerBase.<WriteAsync>d__162>(ref <WriteAsync>d__);
			return <WriteAsync>d__.<>t__builder.Task;
		}

		// Token: 0x040005E8 RID: 1512
		private List<string> TrustedClients = null;

		// Token: 0x040005E9 RID: 1513
		private bool IsTrustedClientsOnly = false;

		// Token: 0x040005EA RID: 1514
		private SimpleHybirdLock lock_trusted_clients;

		// Token: 0x040005EB RID: 1515
		private List<AppSession> listsOnlineClient;

		// Token: 0x040005EC RID: 1516
		private object lockOnlineClient;

		// Token: 0x040005ED RID: 1517
		private int onlineCount = 0;

		// Token: 0x040005EE RID: 1518
		private Timer timerHeart;

		/// <summary>
		/// 当接收到来自客户的数据信息时触发的对象，该数据可能来自tcp或是串口<br />
		/// The object that is triggered when receiving data information from the customer, the data may come from tcp or serial port
		/// </summary>
		/// <param name="sender">本服务器对象</param>
		/// <param name="data">实际的数据信息</param>
		// Token: 0x02000772 RID: 1906
		// (Invoke) Token: 0x060031FF RID: 12799
		public delegate void DataReceivedDelegate(object sender, byte[] data);

		/// <summary>
		/// 数据发送的时候委托<br />
		/// Show DataSend To PLC
		/// </summary>
		/// <param name="sender">数据发送对象</param>
		/// <param name="data">数据内容</param>
		// Token: 0x02000773 RID: 1907
		// (Invoke) Token: 0x06003203 RID: 12803
		public delegate void DataSendDelegate(object sender, byte[] data);
	}
}
